/*!
 * AudioElementPlayer
 *
 * Creates a controller bar for HTML5 <audio> tags
 * using jQuery and AudioElement.js (HTML5 Flash wrapper)
 *
 */
if (typeof jQuery != 'undefined') {
	mejs.$ = jQuery;
} else if (typeof ender != 'undefined') {
	mejs.$ = ender;
}
(function ($) {

	// Default player values
	mejs.MepDefaults = {
            
		// Default if the user doesn't specify
		defaultWidth: 400,
		// Default if the user doesn't specify
		defaultHeight: 30,

		// Default amount to move back when back key is pressed
		defaultSeekBackwardInterval: function(player, media) {
                           return ((player.options.duration > 0) ? (player.options.duration * 0.05) : (media.duration * 0.05));
		},
                        
		// Default amount to move forward when forward key is pressed
		defaultSeekForwardInterval: function(player, media) {
			return ((player.options.duration > 0) ? (player.options.duration * 0.05) : (media.duration * 0.05));
		},

		// Width of audio player
		width: -1,
		// Height of audio player
		height: -1,
		// Initial volume when the player starts (overrided by user cookie)
		startVolume: 0.8,
		// Resize to media dimensions
		enableAutosize: true,
		// Forces the hour marker (##:00:00)
		alwaysShowHours: false,
		// Automatically calculate the width of the progress bar based on the sizes of other elements
		autosizeProgress : true,
		// Features
		features: ['playpause','current','progress','duration','volume', 'captioncustomiser'],

		// Turns keyboard support on and off for this instance
		enableKeyboard: true,

		// When this player starts, it will pause other players
		pauseOtherPlayers: true,

		// Array of keyboard actions
		keyActions: [
                                {
                                    keys: [
                                        32, // SPACE
                                        179 // GOOGLE play/pause button
                                    ],
                                    action: function(player, media)
                                    {
                                        if (media.paused || media.ended)
                                        {
                                            player.play();
                                        } 
                                        else 
                                        {
                                            player.pause();
                                        }
                                    }
				},
				{
                                    keys: [38], // UP
                                    action: function(player, media)
                                    {
                                        player.container.find('.mejs-volume-slider').css('display','block');

                                        var newVolume = Math.min(media.volume + 0.1, 1);
                                        media.setVolume(newVolume);
                                    }
				},
				{
                                    keys: [40], // DOWN
                                    action: function(player, media)
                                    {
                                        player.container.find('.mejs-volume-slider').css('display','block');

                                        var newVolume = Math.max(media.volume - 0.1, 0);
                                        media.setVolume(newVolume);
                                    }
				},
				{
                                    keys: [
                                                    37, // LEFT
                                                    227 // Google TV rewind
                                    ],
                                    action: function(player, media) {
                                                    if ((player.options.duration > 0) || (media.duration > 0)) {

                                                                    // 5%
                                                                    var newTime = Math.max(player.currentTime - player.options.defaultSeekBackwardInterval(player, media), 0);
                                                                    player.setCurrentTime(newTime);
                                                    }
                                    }
				},
				{
                                    keys: [
                                                    39, // RIGHT
                                                    228 // Google TV forward
                                    ],
                                    action: function(player, media) {
                                                    if ((player.options.duration > 0) || (media.duration > 0)) {

                                                                    // 5%
                                                                    var newTime = Math.min(player.currentTime + player.options.defaultSeekForwardInterval(player, media), (player.options.duration > 0) ? player.options.duration : media.duration);
                                                                    player.setCurrentTime(newTime);
                                                    }
                                    }
				},
                                {
                                    keys: [77], // M
                                    action: function(player, media) {
                                        player.container.find('.mejs-volume-slider').css('display','block');
                                        if (player.media.muted) {
                                            player.setMuted(false);
                                        } else {
                                            player.setMuted(true);
                                        }
                                    }
				}
		]
	};

	mejs.mepIndex = 0;

	mejs.players = {};

	// Wraps a MediaElement object in player controls
	mejs.MediaElementPlayer = function(node, o) {

                if ( !(this instanceof mejs.MediaElementPlayer) ) {
			return new mejs.MediaElementPlayer(node, o);
		}

		var t = this;

		// These will be reset after the MediaElement.success fires
		t.$media = t.$node = $(node);
		t.node = t.media = t.$media[0];

		// Check for existing player
		if (typeof t.node.player != 'undefined') {
			return t.node.player;
		} else {
			// Attach player to DOM node for reference
			t.node.player = t;
		}


		// Try to get options from data-mejsoptions
		if (typeof o == 'undefined') {
			o = t.$node.data('mejsoptions');
		}

		// Extend default options
		t.options = $.extend({},mejs.MepDefaults,o);

		// Unique ID
		t.id = 'mep_' + mejs.mepIndex++;

		// Add to player array
		mejs.players[t.id] = t;

		// Start
		t.init();

		return t;
	};

	// Actual player
	mejs.MediaElementPlayer.prototype = {

		hasFocus: false,

		controlsAreVisible: true,

		init: function() {

			var
				t = this,
				mf = mejs.MediaFeatures,
				// Options for MediaElement (shim)
				meOptions = $.extend(true, {}, t.options, {
					success: function(media, domNode) { t.meReady(media, domNode); },
					error: function(e) { t.handleError(e);}
				}),
				tagName = t.media.tagName.toLowerCase();

			t.isDynamic = tagName !== 'audio';

                        // Remove native controls
                        t.$media.removeAttr('controls');

                        // Build container
                        t.container =
                                $('<div id="' + t.id + '" class="mejs-container ' + (mejs.MediaFeatures.svg ? 'svg' : 'no-svg') + '">'+
                                        '<div class="mejs-inner">'+
                                                '<div class="mejs-mediaelement"></div>'+
                                                '<div class="mejs-layers"></div>'+
                                                '<div class="mejs-controls"></div>'+
                                                '<div class="mejs-clear"></div>'+
                                        '</div>' +
                                '</div>')
                                .addClass(t.$media[0].className)
                                .insertBefore(t.$media);

                        // Add classes for user and content
                        t.container.addClass(
                                (mf.isAndroid ? 'mejs-android ' : '') +
                                (mf.isiOS ? 'mejs-ios ' : '') +
                                (mf.isiPad ? 'mejs-ipad ' : '') +
                                (mf.isiPhone ? 'mejs-iphone ' : '') +
                                ('mejs-audio ')
                        );


                        // Move the <audio> tag into the right spot
                        if (mf.isiOS) {

                                // Sadly, you can't move nodes in iOS, so we have to destroy and recreate it!
                                var $newMedia = t.$media.clone();

                                t.container.find('.mejs-mediaelement').append($newMedia);

                                t.$media.remove();
                                t.$node = t.$media = $newMedia;
                                t.node = t.media = $newMedia[0]

                        } else {

                                // Normal way of moving it into place (doesn't work on iOS)
                                t.container.find('.mejs-mediaelement').append(t.$media);
                        }

                        // Find parts
                        t.controls = t.container.find('.mejs-controls');
                        t.layers = t.container.find('.mejs-layers');
                        
                        // Determine the size

                        if (t.options.width > 0 || t.options.width.toString().indexOf('%') > -1) {
                                t.width = t.options.width;
                        } else if (t.media.style.width !== '' && t.media.style.width !== null) {
                                t.width = t.media.style.width;
                        } else if (t.media.getAttribute('width') !== null) {
                                t.width = t.$media.attr('width');
                        } else {
                                t.width = t.options.defaultWidth;
                        }

                        if (t.options.height > 0 || t.options.height.toString().indexOf('%') > -1) {
                                t.height = t.options.height;
                        } else if (t.media.style.height !== '' && t.media.style.height !== null) {
                                t.height = t.media.style.height;
                        } else if (t.$media[0].getAttribute('height') !== null) {
                                t.height = t.$media.attr('height');
                        } else {
                                t.height = t.options.defaultHeight;
                        }

                        // Set the size, while we wait for the plugins to load below
                        t.setPlayerSize(t.width, t.height);

			// create MediaElement shim
			mejs.MediaElement(t.$media[0], meOptions);

			if (typeof(t.container) != 'undefined' && t.controlsAreVisible){
			    // Controls are shown when loaded
			    t.container.trigger('controlsshown');
			}
		},
                        
		showControls: function(doAnimation) {
			var t = this;

			doAnimation = typeof doAnimation == 'undefined' || doAnimation;

			if (t.controlsAreVisible)
				return;

			if (doAnimation) {
				t.controls
					.css('visibility','visible')
					.stop(true, true).fadeIn(200, function() {
					      t.controlsAreVisible = true;
					      t.container.trigger('controlsshown');
					});

				// Any additional controls people might add and want to hide
				t.container.find('.mejs-control')
					.css('visibility','visible')
					.stop(true, true).fadeIn(200, function() {t.controlsAreVisible = true;});

			} else {
				t.controls
					.css('visibility','visible')
					.css('display','block');

				// Any additional controls people might add and want to hide
				t.container.find('.mejs-control')
					.css('visibility','visible')
					.css('display','block');

				t.controlsAreVisible = true;
				t.container.trigger('controlsshown');
			}

			t.setControlsSize();

		},

		controlsEnabled: true,

		disableControls: function() {
			var t= this;

			this.controlsEnabled = false;
		},

		enableControls: function() {
			var t= this;

			t.showControls(false);

			t.controlsEnabled = true;
		},


		// Sets up all controls and events
		meReady: function(media, domNode) {


			var t = this,
				mf = mejs.MediaFeatures,
				autoplayAttr = domNode.getAttribute('autoplay'),
				autoplay = !(typeof autoplayAttr == 'undefined' || autoplayAttr === null || autoplayAttr === 'false'),
				featureIndex,
				feature;

			// Make sure it can't create itself again if a plugin reloads
			if (t.created) {
				return;
			} else {
				t.created = true;
			}

			t.media = media;
			t.domNode = domNode;

                        t.buildkeyboard(t, t.controls, t.layers, t.media);

                        // Add user-defined features/controls
                        for (featureIndex in t.options.features) {
                                feature = t.options.features[featureIndex];
                                if (t['build' + feature]) {
                                        try {
                                                t['build' + feature](t, t.controls, t.layers, t.media);
                                        } catch (e) {

                                        }
                                }
                        }

                        t.container.trigger('controlsready');

                        // Reset all layers and controls
                        t.setPlayerSize(t.width, t.height);
                        t.setControlsSize();

                        // EVENTS

                        // FOCUS: When a player starts playing, it takes focus from other players (possibily pausing them)
                        media.addEventListener('play', function() {
                                var playerIndex;

                                // Go through all other players
                                for (playerIndex in mejs.players) {
                                        var p = mejs.players[playerIndex];
                                        if (p.id != t.id && t.options.pauseOtherPlayers && !p.paused && !p.ended) {
                                                p.pause();
                                        }
                                        p.hasFocus = false;
                                }

                                t.hasFocus = true;
                        },false);


                        // Ended for all
                        t.media.addEventListener('ended', function (e) {

                                t.media.pause();

                                if (t.setCurrentRail) {
                                        t.setCurrentRail();
                                }
                                
                        }, false);

                        // Resize on the first play
                        t.media.addEventListener('loadedmetadata', function(e) {
                                if (t.updateDuration) {
                                        t.updateDuration();
                                }
                                if (t.updateCurrent) {
                                        t.updateCurrent();
                                }

                        }, false);


                        // Webkit has trouble doing this without a delay
                        setTimeout(function () {
                                t.setPlayerSize(t.width, t.height);
                                t.setControlsSize();
                        }, 50);

                        // Adjust controls whenever window sizes.
                        t.globalBind('resize', function() {

                                // Adjust controls
                                t.setControlsSize();
                        });

			// Force autoplay for HTML5
			if (autoplay && media.pluginType == 'native') {
				t.play();
			}


			if (t.options.success) {

				if (typeof t.options.success == 'string') {
					window[t.options.success](t.media, t.domNode, t);
				} else {
					t.options.success(t.media, t.domNode, t);
				}
			}
		},

		handleError: function(e) {
			var t = this;

			t.controls.hide();

			// Tell user that the file cannot be played
			if (t.options.error) {
				t.options.error(e);
			}
		},

		setPlayerSize: function(width,height) {
			var t = this;

			if (typeof width != 'undefined') {
				t.width = width;
			}

			if (typeof height != 'undefined') {
				t.height = height;
			}

			// Detect 100% mode - use currentStyle for IE since css() doesn't return percentages
                        if (t.height.toString().indexOf('%') > 0 || t.$node.css('max-width') === '100%' || parseInt(t.$node.css('max-width').replace(/px/,''), 10) / t.$node.offsetParent().width() === 1 || (t.$node[0].currentStyle && t.$node[0].currentStyle.maxWidth === '100%')) {

				// Do we have the native dimensions yet?
				var
					nativeWidth = t.options.defaultWidth,
					nativeHeight = t.options.defaultHeight;

				if (t.container.parent()[0].tagName.toLowerCase() === 'body') {
					nativeWidth = $(window).width();
					nativeHeight = $(window).height();
				}

				if ( nativeHeight != 0 && nativeWidth != 0 ) {
					// Set outer container size
					t.container
						.width(nativeWidth)
						.height(nativeHeight);

					// Set native <audio> and shims
					t.$media.add(t.container.find('.mejs-shim'))
						.width('100%')
						.height('100%');

					// Set the layers
					t.layers.children('.mejs-layer')
						.width('100%')
						.height('100%');
				}


			} else {

				t.container
					.width(t.width)
					.height(t.height);

				t.layers.children('.mejs-layer')
					.width(t.width)
					.height(t.height);

			}
		},

		setControlsSize: function() {
			var t = this,
				usedWidth = 0,
				railWidth = 0,
				rail = t.controls.find('.mejs-time-rail'),
				total = t.controls.find('.mejs-time-total'),
				current = t.controls.find('.mejs-time-current'),
				loaded = t.controls.find('.mejs-time-loaded'),
				others = rail.siblings();


			// Allow the size to come from custom CSS
			if (t.options && !t.options.autosizeProgress) {
				railWidth = parseInt(rail.css('width'));
			}

			// Attempt to autosize
			if (railWidth === 0 || !railWidth) {

				// Find the size of all the other controls besides the rail
				others.each(function() {
					var $this = $(this);
					if ($this.css('position') != 'absolute' && $this.is(':visible')) {
						usedWidth += $(this).outerWidth(true);
					}
				});

				// Fit the rail into the remaining space
				railWidth = t.controls.width() - usedWidth - (rail.outerWidth(true) - rail.width());
			}

			// Outer area
			rail.width(railWidth);
			// Dark space
			total.width(railWidth - (total.outerWidth(true) - total.width()));

			if (t.setCurrentRail)
				t.setCurrentRail();
		},

		buildkeyboard: function(player, controls, layers, media) {

				var t = this;

				// Listen for key presses
				t.globalBind('keydown', function(e) {

						if (player.hasFocus && player.options.enableKeyboard) {

								// Find a matching key
								for (var i=0, il=player.options.keyActions.length; i<il; i++) {
										var keyAction = player.options.keyActions[i];

										for (var j=0, jl=keyAction.keys.length; j<jl; j++) {
												if (e.keyCode == keyAction.keys[j]) {
														e.preventDefault();
														keyAction.action(player, media, e.keyCode);
														return false;
												}
										}
								}
						}

						return true;
				});

				// Check if someone clicked outside a player region, then kill its focus
				t.globalBind('click', function(event) {
						if ($(event.target).closest('.mejs-container').length == 0) {
								player.hasFocus = false;
						}
				});

		},
                        
		changeSkin: function(className) {
			this.container[0].className = 'mejs-container ' + className;
			this.setPlayerSize(this.width, this.height);
			this.setControlsSize();
		},
                        
		play: function()
                {
                    this.media.play();
		},
                        
		pause: function() {
			try {
				this.media.pause();
			} catch (e) {}
		},
                        
		load: function()
                {
                    this.media.load();
		},
                        
		setMuted: function(muted) {
			this.media.setMuted(muted);
		},
                        
		setCurrentTime: function(time) {
			this.media.setCurrentTime(time);
		},
                        
		getCurrentTime: function() {
			return this.media.currentTime;
		},
                        
		setVolume: function(volume) {
			this.media.setVolume(volume);
		},
                        
		getVolume: function() {
			return this.media.volume;
		},
                        
		setSrc: function(src) {
			this.media.setSrc(src);
		},
                        
		remove: function() {
			var t = this, featureIndex, feature;

			// Invoke features cleanup
			for (featureIndex in t.options.features) {
				feature = t.options.features[featureIndex];
				if (t['clean' + feature]) {
					try {
						t['clean' + feature](t);
					} catch (e) {
                                            
					}
				}
			}

			// Grab audio element and put it back in place
			if (!t.isDynamic) {
				t.$media.prop('controls', true);
				t.$node.clone().show().insertBefore(t.container);
				t.$node.remove();
			} else {
				t.$node.insertBefore(t.container);
			}

			if (t.media.pluginType !== 'native') {
				t.media.remove();
			}

			// Remove the player from the mejs.players object so that pauseOtherPlayers doesn't blow up when trying to pause a non existance flash api.
			delete mejs.players[t.id];

			t.container.remove();
			t.globalUnbind();
			delete t.node.player;
		}
	};

	(function(){
		var rwindow = /^((after|before)print|(before)?unload|hashchange|message|o(ff|n)line|page(hide|show)|popstate|resize|storage)\b/;

		function splitEvents(events, id) {
			// Add player ID as an event namespace so it's easier to unbind them all later
			var ret = {d: [], w: []};
			$.each((events || '').split(' '), function(k, v){
				var eventname = v + '.' + id;
				if (eventname.indexOf('.') === 0) {
					ret.d.push(eventname);
					ret.w.push(eventname);
				}
				else {
					ret[rwindow.test(v) ? 'w' : 'd'].push(eventname);
				}
			});
			ret.d = ret.d.join(' ');
			ret.w = ret.w.join(' ');
			return ret;
		}

		mejs.MediaElementPlayer.prototype.globalBind = function(events, data, callback) {
			var t = this;
			events = splitEvents(events, t.id);
			if (events.d) $(document).bind(events.d, data, callback);
			if (events.w) $(window).bind(events.w, data, callback);
		};

		mejs.MediaElementPlayer.prototype.globalUnbind = function(events, callback) {
			var t = this;
			events = splitEvents(events, t.id);
			if (events.d) $(document).unbind(events.d, callback);
			if (events.w) $(window).unbind(events.w, callback);
		};
	})();

	// Turn into jQuery plugin
	if (typeof jQuery != 'undefined') {
		jQuery.fn.mediaelementplayer = function (options) {
			if (options === false) {
				this.each(function () {
					var player = jQuery(this).data('mediaelementplayer');
					if (player) {
						player.remove();
					}
					jQuery(this).removeData('mediaelementplayer');
				});
			}
			else {
				this.each(function () {
					jQuery(this).data('mediaelementplayer', new mejs.MediaElementPlayer(this, options));
				});
			}
			return this;
		};
	}

	$(document).ready(function() {
		// Auto enable using JSON attribute
		$('.mejs-player').mediaelementplayer();
	});

	// Push out to window
	window.MediaElementPlayer = mejs.MediaElementPlayer;

})(mejs.$);

(function($) {

	$.extend(mejs.MepDefaults, {
		playpauseText: 'Play/Pause'
	});

	// PLAY/PAUSE BUTTON
	$.extend(MediaElementPlayer.prototype, {
		buildplaypause: function(player, controls, layers, media) {
			var 
				t = this,
				play = 
				$('<div class="mejs-button mejs-playpause-button mejs-play" >' +
					'<button type="button" aria-controls="' + t.id + '" title="' + t.options.playpauseText + '" aria-label="' + t.options.playpauseText + '"></button>' +
				'</div>')
				.appendTo(controls)
				.click(function(e) {
					e.preventDefault();
				
					if (media.paused) {
						media.play();
					} else {
						media.pause();
					}
					
					return false;
				});

			media.addEventListener('play',function() {
				play.removeClass('mejs-play').addClass('mejs-pause');
			}, false);
                        
			media.addEventListener('playing',function() {
				play.removeClass('mejs-play').addClass('mejs-pause');
			}, false);

			media.addEventListener('pause',function() {
				play.removeClass('mejs-pause').addClass('mejs-play');
			}, false);
                        
			media.addEventListener('paused',function() {
				play.removeClass('mejs-pause').addClass('mejs-play');
			}, false);
		}
	});
	
})(mejs.$);

(function($) {
	// Progress Bar
	$.extend(MediaElementPlayer.prototype, {
		buildprogress: function(player, controls, layers, media) {

			$('<div class="mejs-time-rail">'+
				'<span class="mejs-time-total">'+
					'<span class="mejs-time-buffering"></span>'+
					'<span class="mejs-time-loaded"></span>'+
					'<span class="mejs-time-current"></span>'+
					'<span class="mejs-time-handle"></span>'+
					'<span class="mejs-time-float">' + 
						'<span class="mejs-time-float-current">00:00</span>' + 
						'<span class="mejs-time-float-corner"></span>' + 
					'</span>'+
				'</span>'+
			'</div>')
				.appendTo(controls);
				controls.find('.mejs-time-buffering').hide();

			var 
				t = this,
				total = controls.find('.mejs-time-total'),
				loaded  = controls.find('.mejs-time-loaded'),
				current  = controls.find('.mejs-time-current'),
				handle  = controls.find('.mejs-time-handle'),
				timefloat  = controls.find('.mejs-time-float'),
				timefloatcurrent  = controls.find('.mejs-time-float-current'),
				handleMouseMove = function (e) {
                                        // Mouse position relative to the object
                                        var x = e.pageX,
                                        offset = total.offset(),
                                        width = total.outerWidth(true),
                                        percentage = 0,
                                        newTime = 0,
                                        pos = 0;


					if (media.duration || t.options.duration) {
						if (x < offset.left) {
							x = offset.left;
						} else if (x > width + offset.left) {
							x = width + offset.left;
						}
						
						pos = x - offset.left;
						percentage = (pos / width);
                                                
                                                newTime = percentage * (t.options.duration ? t.options.duration : media.duration);

						// Seek to where the mouse is
						if (mouseIsDown && newTime !== t.currentTime) {
                                                        t.setCurrentTime(newTime);
                                                }

						// Position floating time box
						if (!mejs.MediaFeatures.hasTouch) {
								timefloat.css('left', pos);
								timefloatcurrent.html( mejs.Utility.secondsToTimeCode(newTime) );
								timefloat.show();
						}
					}
				},
				mouseIsDown = false,
				mouseIsOver = false;

			// Handle clicks
			total
				.bind('mousedown', function (e) {
                                    // Only handle left clicks
                                    if (e.which === 1 || e.which === 0) {
						mouseIsDown = true;
						handleMouseMove(e);
						t.globalBind('mousemove.dur', function(e) {
							handleMouseMove(e);
						});
						t.globalBind('mouseup.dur', function (e) {
							mouseIsDown = false;
							timefloat.hide();
							t.globalUnbind('.dur');
						});
						return false;
					}
				})
				.bind('mouseenter', function(e) {
					mouseIsOver = true;
					t.globalBind('mousemove.dur', function(e) {
						handleMouseMove(e);
					});
					if (!mejs.MediaFeatures.hasTouch) {
						timefloat.show();
					}
				})
				.bind('mouseleave',function(e) {
					mouseIsOver = false;
					if (!mouseIsDown) {
						t.globalUnbind('.dur');
						timefloat.hide();
					}
				});

			// Loading
			media.addEventListener('progress', function (e) {
				player.setProgressRail(e);
				player.setCurrentRail(e);
			}, false);

			// Current time
			media.addEventListener('timeupdate', function(e) {
				player.setProgressRail(e);
				player.setCurrentRail(e);
			}, false);
			
			
			// Store for later use
			t.loaded = loaded;
			t.total = total;
			t.current = current;
			t.handle = handle;
		},
		setProgressRail: function(e) {

			var
				t = this,
				target = (e != undefined) ? e.target : t.media,
				percent = null;			

			// newest HTML5 spec has buffered array (FF4, Webkit)
			if (target && target.buffered && target.buffered.length > 0 && target.buffered.end && target.duration) {
				// TODO: account for a real array with multiple values (only Firefox 4 has this so far) 
				percent = target.buffered.end(0) / target.duration;
			} 
			// Some browsers (e.g., FF3.6 and Safari 5) cannot calculate target.bufferered.end()
			// to be anything other than 0. If the byte count is available we use this instead.
			// Browsers that support the else if do not seem to have the bufferedBytes value and
			// should skip to there. Tested in Safari 5, Webkit head, FF3.6, Chrome 6, IE 7/8.
			else if (target && target.bytesTotal != undefined && target.bytesTotal > 0 && target.bufferedBytes != undefined) {
				percent = target.bufferedBytes / target.bytesTotal;
			}
			// Firefox 3 with an Ogg file seems to go this way
			else if (e && e.lengthComputable && e.total != 0) {
				percent = e.loaded/e.total;
			}

			// finally update the progress bar
			if (percent !== null) {
				percent = Math.min(1, Math.max(0, percent));
				// update loaded bar
				if (t.loaded && t.total) {
					t.loaded.width(t.total.width() * percent);
				}
			}
		},
		setCurrentRail: function() {

			var t = this;
		
                        if (t.currentTime && (t.options.duration > 0) || (t.media.duration > 0)) {
                            // Update bar
                            if (t.total && t.handle) {
                                    var 
                                            newWidth = Math.round(t.total.width() * t.currentTime / (t.options.duration ? t.options.duration : t.media.duration)),
                                            handlePos = newWidth - Math.round(t.handle.outerWidth(true) / 2);

                                    t.current.width(newWidth);
                                    t.handle.css('left', handlePos);
                            }
                        }

		}
	});
})(mejs.$);
// Source Chooser Plugin
(function($) {

	$.extend(mejs.MepDefaults, {
		sourcechooserText: 'Source Chooser'
	});

	$.extend(MediaElementPlayer.prototype, {
		buildsourcechooser: function(player, controls, layers, media) {

			var t = this;

			player.sourcechooserButton =
				$('<div class="mejs-button mejs-sourcechooser-button">'+
					'<button type="button" aria-controls="' + t.id + '" title="' + t.options.sourcechooserText + '" aria-label="' + t.options.sourcechooserText + '"></button>'+
					'<div class="mejs-sourcechooser-selector">'+
						'<ul>'+
						'</ul>'+
					'</div>'+
				'</div>')
					.appendTo(controls)

					// hover
					.hover(function() {
						$(this).find('.mejs-sourcechooser-selector').css('visibility','visible');
					}, function() {
						$(this).find('.mejs-sourcechooser-selector').css('visibility','hidden');
					})

					// handle clicks to the language radio buttons
					.delegate('input[type=radio]', 'click', function() {
						src = this.value;

						if (media.currentSrc != src) {
							currentTime = media.currentTime;
							paused = media.paused;
							media.setSrc(src);
							media.load();
							media.addEventListener('loadedmetadata', function(e){
				                this.currentTime = currentTime;
				            }, true);
				            media.addEventListener('canplay', function(e){
				            	if (!paused) {
					            	this.play();
					            }
				            }, true);
						}
					});

			// add to list
			for (i in media.children) {
				src = media.children[i];
				if (src.nodeName === 'SOURCE' && (media.canPlayType(src.type) == 'probably' || media.canPlayType(src.type) == 'maybe')) {
					player.addSourceButton(src.src, src.title, src.type, media.src == src.src);
				}
			}

		},

		addSourceButton: function(src, label, type, isCurrent) {
			var t = this;
			if (label === '' || label == undefined) {
				label = src;
			}
			type = type.split('/')[1];

			t.sourcechooserButton.find('ul').append(
				$('<li>'+
					'<input type="radio" name="' + t.id + '_sourcechooser" id="' + t.id + '_sourcechooser_' + label + type + '" value="' + src + '" ' + (isCurrent ? 'checked="checked"' : '') + ' />'+
					'<label for="' + t.id + '_sourcechooser_' + label + type + '">' + label + ' (' + type + ')</label>'+
				'</li>')
			);

			t.adjustSourcechooserBox();

		},

		adjustSourcechooserBox: function() {
			var t = this;
			// adjust the size of the outer box
			t.sourcechooserButton.find('.mejs-sourcechooser-selector').height(
				t.sourcechooserButton.find('.mejs-sourcechooser-selector ul').outerHeight(true)
			);
		}
	});

})(mejs.$);

(function($) {
	
	// Options
	$.extend(mejs.MepDefaults, {
		timeAndDurationSeparator: '<span> | </span>'
	});


	// Time
	$.extend(MediaElementPlayer.prototype, {
		buildcurrent: function(player, controls, layers, media) {
			var t = this;
			
			$('<div class="mejs-time">'+
					'<span class="mejs-currenttime">' + (player.options.alwaysShowHours ? '00:00:00' : '00:00')
					+ '</span>'+ '</div>')
					.appendTo(controls);
			
			t.currenttime = t.controls.find('.mejs-currenttime');

                            
                        media.addEventListener('timeupdate',function() {
                            player.updateCurrent();
                            player.currentTime = media.currentTime;

                        }, false);
                            
		},


		buildduration: function(player, controls, layers, media) {
			var t = this;
			
			if (controls.children().last().find('.mejs-currenttime').length > 0) {
				$(t.options.timeAndDurationSeparator +
					'<span class="mejs-duration">' + 
						(t.options.duration > 0 ? 
							mejs.Utility.secondsToTimeCode(t.options.duration, t.options.alwaysShowHours || t.media.duration > 3600) :
				   			(player.options.alwaysShowHours ? '00:00:00' : '00:00') 
				   		) + 
					'</span>')
					.appendTo(controls.find('.mejs-time'));
			} else {

				// Add class to current time
				controls.find('.mejs-currenttime').parent().addClass('mejs-currenttime-container');
				
				$('<div class="mejs-time mejs-duration-container">'+
					'<span class="mejs-duration">' + 
						(t.options.duration > 0 ? 
							mejs.Utility.secondsToTimeCode(t.options.duration, t.options.alwaysShowHours || t.options.duration > 3600) :
				   			(player.options.alwaysShowHours ? '00:00:00' : '00:00') 
				   		) + 
					'</span>' +
				'</div>')
				.appendTo(controls);
			}
			
			t.durationD = t.controls.find('.mejs-duration');

                        media.addEventListener('timeupdate',function() {
                            player.updateDuration();
                        }, false);
		},
		
		updateCurrent:  function() {
            
			var t = this;

			if (t.currenttime) {
                            t.currenttime.html(mejs.Utility.secondsToTimeCode(t.currentTime, t.options.alwaysShowHours || (t.options.duration ? t.options.duration > 3600 : t.media.duration > 3600)));
                        }
		},
		
		updateDuration: function() {   
			var t = this;

			//Toggle the long audio class if the audio is longer than an hour.
                        if(t.options.duration > 0)
                            t.container.toggleClass("mejs-long-audio", t.options.duration > 3600);
                        else
                            t.container.toggleClass("mejs-long-audio", t.media.duration > 3600);
			
			if (t.durationD && (t.options.duration > 0 || t.media.duration > 0)) {
				t.durationD.html(mejs.Utility.secondsToTimeCode((t.options.duration ? t.options.duration : t.media.duration), t.options.alwaysShowHours));
			}	
                }
	});

})(mejs.$);

(function($) {

	$.extend(mejs.MepDefaults, {
		muteText: 'Mute Toggle',
		hideVolumeOnTouchDevices: true,
	});

	$.extend(MediaElementPlayer.prototype, {
		buildvolume: function(player, controls, layers, media) {
				
			// Android and iOS don't support volume controls
			if (mejs.MediaFeatures.hasTouch && this.options.hideVolumeOnTouchDevices)
				return;
			
			var t = this,
				mode = t.options.audioVolume,
				mute =
				
				// Horizontal version
				$('<div class="mejs-button mejs-volume-button mejs-mute">'+
					'<button type="button" aria-controls="' + t.id + '" title="' + t.options.muteText + '" aria-label="' + t.options.muteText + '"></button>'+
				'</div>' +
				'<div class="mejs-horizontal-volume-slider">'+ // Outer background
					'<div class="mejs-horizontal-volume-total"></div>'+ // Line background
					'<div class="mejs-horizontal-volume-current"></div>'+ // Current volume
					'<div class="mejs-horizontal-volume-handle"></div>'+ // Handle
				'</div>'
				)
					.appendTo(controls),
			volumeSlider = t.container.find('.mejs-volume-slider, .mejs-horizontal-volume-slider'),
			volumeTotal = t.container.find('.mejs-volume-total, .mejs-horizontal-volume-total'),
			volumeCurrent = t.container.find('.mejs-volume-current, .mejs-horizontal-volume-current'),
			volumeHandle = t.container.find('.mejs-volume-handle, .mejs-horizontal-volume-handle'),

			positionVolumeHandle = function(volume, secondTry) {

				if (!volumeSlider.is(':visible') && typeof secondTry == 'undefined') {
					volumeSlider.show();
					positionVolumeHandle(volume, true);
					volumeSlider.hide()
					return;
				}
			
				// Correct to 0-1
				volume = Math.max(0,volume);
				volume = Math.min(volume,1);					
				
				// Adjust mute button style
				if (volume == 0) {
					mute.removeClass('mejs-mute').addClass('mejs-unmute');
				} else {
					mute.removeClass('mejs-unmute').addClass('mejs-mute');
				}				

				// Position slider 
				if (mode == 'vertical') {
                                    
					var 
					
                                        // Height of the full size volume slider background
                                        totalHeight = volumeTotal.height(),

                                        // Top/left of full size volume slider background
                                        totalPosition = volumeTotal.position(),

                                        // The new top position based on the current volume
                                        newTop = totalHeight - (totalHeight * volume);
	
					// Handle
					volumeHandle.css('top', Math.round(totalPosition.top + newTop - (volumeHandle.height() / 2)));
	
					// Show the current visibility
					volumeCurrent.height(totalHeight - newTop );
					volumeCurrent.css('top', totalPosition.top + newTop);
				} else {
                                    
					var 
					
                                        // Height of the full size volume slider background
                                        totalWidth = volumeTotal.width(),

                                        // Top/left of full size volume slider background
                                        totalPosition = volumeTotal.position(),

                                        // The new left position based on the current volume
                                        newLeft = totalWidth * volume;
	
					// Handle
					volumeHandle.css('left', Math.round(totalPosition.left + newLeft - (volumeHandle.width() / 2)));
	
					// Rezize the current part of the volume bar
					volumeCurrent.width( Math.round(newLeft) );
				}
			},
                                
			handleVolumeMove = function(e) {
				
				var volume = null,
					totalOffset = volumeTotal.offset();
				
				// Calculate the new volume based on the mouse position
				if (mode == 'vertical') {
				
					var
                                        
                                        railHeight = volumeTotal.height(),
                                        totalTop = parseInt(volumeTotal.css('top').replace(/px/,''),10),
                                        newY = e.pageY - totalOffset.top;
						
					volume = (railHeight - newY) / railHeight;
						
					// The controls hide themselves (usually when mouse moves too far up)
					if (totalOffset.top == 0 || totalOffset.left == 0)
						return;
					
				} else {
					var
                                        
                                        railWidth = volumeTotal.width(),
                                        newX = e.pageX - totalOffset.left;
						
					volume = newX / railWidth;
				}
				
				// Ensure the volume isn't outside 0-1
				volume = Math.max(0,volume);
				volume = Math.min(volume,1);
				
				// Position the slider and handle			
				positionVolumeHandle(volume);
				
				// Set the media object (this will trigger the volumechanged event)
				if (volume == 0) {
					media.setMuted(true);
				} else {
					media.setMuted(false);
				}
				media.setVolume(volume);			
			},
			mouseIsDown = false,
			mouseIsOver = false;

			// SLIDER
			
			mute
				.hover(function() {
					volumeSlider.show();
					mouseIsOver = true;
				}, function() {
					mouseIsOver = false;	
						
					if (!mouseIsDown && mode == 'vertical')	{
						volumeSlider.hide();
					}
				});
			
			volumeSlider
				.bind('mouseover', function() {
					mouseIsOver = true;	
				})
				.bind('mousedown', function (e) {
					handleVolumeMove(e);
					t.globalBind('mousemove.vol', function(e) {
						handleVolumeMove(e);
					});
					t.globalBind('mouseup.vol', function () {
						mouseIsDown = false;
						t.globalUnbind('.vol');

						if (!mouseIsOver && mode == 'vertical') {
							volumeSlider.hide();
						}
					});
					mouseIsDown = true;
						
					return false;
				});


			// MUTE button
			mute.find('button').click(function() {
				media.setMuted( !media.muted );
			});

			// Listen for volume change events from other sources
			media.addEventListener('volumechange', function(e) {
				if (!mouseIsDown) {
					if (media.muted) {
						positionVolumeHandle(0);
						mute.removeClass('mejs-mute').addClass('mejs-unmute');
					} else {
						positionVolumeHandle(media.volume);
						mute.removeClass('mejs-unmute').addClass('mejs-mute');
					}
				}
			}, false);

			if (t.container.is(':visible')) {
				// Set initial volume
				positionVolumeHandle(player.options.startVolume);

				// Mutes the media and sets the volume icon muted if the initial volume is set to 0
                                if (player.options.startVolume === 0) {
                                  media.setMuted(true);
                                }

				// Shim gets the startvolume as a parameter, but we have to set it on the native <audio> elements
				if (media.pluginType === 'native') {
					media.setVolume(player.options.startVolume);
				}
			}
		}
	});
	
})(mejs.$);

/*
* ContextMenu Plugin
* 
*
*/

(function($) {

$.extend(mejs.MepDefaults,
	{ 'contextMenuItems': [
		// demo of a mute/unmute button
		{ 
			render: function(player) {
				if (player.media.muted) {
					return 'Unmute';
				} else {
					return 'Mute';
				}
			},
			click: function(player) {
				if (player.media.muted) {
					player.setMuted(false);
				} else {
					player.setMuted(true);
				}
			}
		},
		// separator
		{
			isSeparator: true
		}
		,
		// demo of simple download
		{ 
			render: function(player) {
				return 'Download File';
			},
			click: function(player) {
				window.location.href = player.media.currentSrc;
			}
		}	
	]}
);


	$.extend(MediaElementPlayer.prototype, {
		buildcontextmenu: function(player, controls, layers, media) {
			
			// create context menu
			player.contextMenu = $('<div class="mejs-contextmenu"></div>')
								.appendTo($('body'))
								.hide();
			
			// create events for showing context menu
			player.container.bind('contextmenu', function(e) {
				if (player.isContextMenuEnabled) {
					e.preventDefault();
					player.renderContextMenu(e.clientX-1, e.clientY-1);
					return false;
				}
			});
			player.container.bind('click', function() {
				player.contextMenu.hide();
			});	
			player.contextMenu.bind('mouseleave', function() {

				//
				player.startContextMenuTimer();
				
			});		
		},

		cleancontextmenu: function(player) {
			player.contextMenu.remove();
		},
		
		isContextMenuEnabled: true,
		enableContextMenu: function() {
			this.isContextMenuEnabled = true;
		},
		disableContextMenu: function() {
			this.isContextMenuEnabled = false;
		},
		
		contextMenuTimeout: null,
		startContextMenuTimer: function() {
			//
			
			var t = this;
			
			t.killContextMenuTimer();
			
			t.contextMenuTimer = setTimeout(function() {
				t.hideContextMenu();
				t.killContextMenuTimer();
			}, 750);
		},
		killContextMenuTimer: function() {
			var timer = this.contextMenuTimer;
			
			//
			
			if (timer != null) {				
				clearTimeout(timer);
				delete timer;
				timer = null;
			}
		},		
		
		hideContextMenu: function() {
			this.contextMenu.hide();
		},
		
		renderContextMenu: function(x,y) {
			
			// alway re-render the items so that things like "turn fullscreen on" and "turn fullscreen off" are always written correctly
			var t = this,
				html = '',
				items = t.options.contextMenuItems;
			
			for (var i=0, il=items.length; i<il; i++) {
				
				if (items[i].isSeparator) {
					html += '<div class="mejs-contextmenu-separator"></div>';
				} else {
				
					var rendered = items[i].render(t);
				
					// render can return null if the item doesn't need to be used at the moment
					if (rendered != null) {
						html += '<div class="mejs-contextmenu-item" data-itemindex="' + i + '" id="element-' + (Math.random()*1000000) + '">' + rendered + '</div>';
					}
				}
			}
			
			// position and show the context menu
			t.contextMenu
				.empty()
				.append($(html))
				.css({top:y, left:x})
				.show();
				
			// bind events
			t.contextMenu.find('.mejs-contextmenu-item').each(function() {
							
				// which one is this?
				var $dom = $(this),
					itemIndex = parseInt( $dom.data('itemindex'), 10 ),
					item = t.options.contextMenuItems[itemIndex];
				
				// bind extra functionality?
				if (typeof item.show != 'undefined')
					item.show( $dom , t);
				
				// bind click action
				$dom.click(function() {			
					// perform click action
					if (typeof item.click != 'undefined')
						item.click(t);
					
					// close
					t.contextMenu.hide();				
				});				
			});			
		}
	});
	
})(mejs.$);
